home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / Corine.swf / scripts / __Packages / MochiAd.as
Encoding:
Text File  |  2011-10-17  |  29.0 KB  |  804 lines
  1. function ┬º\x04\x05┬º()
  2. {
  3.    set("\x03",1660 % 511 * 5);
  4.    return eval("\x03");
  5. }
  6. var ┬º\x01┬º = 155 + "\x04\x05"();
  7. while(true)
  8. {
  9.    if(eval("\x01") == 790)
  10.    {
  11.       set("\x01",eval("\x01") - 258);
  12.       ┬º┬ºpush(true);
  13.    }
  14.    else
  15.    {
  16.       if(eval("\x01") == 489)
  17.       {
  18.          set("\x01",eval("\x01") + 147);
  19.          if(!_global.MochiAd)
  20.          {
  21.             var _loc2_ = _global.MochiAd = function()
  22.             {
  23.             }.prototype;
  24.             _global.MochiAd = function()
  25.             {
  26.             }.getVersion = function()
  27.             {
  28.                return "2.7";
  29.             };
  30.             _global.MochiAd = function()
  31.             {
  32.             }.showPreGameAd = function(options)
  33.             {
  34.                var _loc26_ = {clip:_root,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812,no_progress_bar:false,ad_started:function()
  35.                {
  36.                   this.clip.stop();
  37.                },ad_finished:function()
  38.                {
  39.                   this.clip.play();
  40.                },ad_failed:function()
  41.                {
  42.                   trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  43.                },ad_loaded:function(width, height)
  44.                {
  45.                },ad_skipped:function()
  46.                {
  47.                },ad_progress:function(percent)
  48.                {
  49.                }};
  50.                options = MochiAd._parseOptions(options,_loc26_);
  51.                if("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def")
  52.                {
  53.                   options.ad_started();
  54.                   options.ad_finished();
  55.                   return undefined;
  56.                }
  57.                var clip = options.clip;
  58.                var _loc22_ = 11000;
  59.                var _loc25_ = options.ad_timeout;
  60.                delete options.ad_timeout;
  61.                var fadeout_time = options.fadeout_time;
  62.                delete options.fadeout_time;
  63.                if(!MochiAd.load(options))
  64.                {
  65.                   options.ad_failed();
  66.                   options.ad_finished();
  67.                   return undefined;
  68.                }
  69.                options.ad_started();
  70.                var mc = clip._mochiad;
  71.                mc.onUnload = function()
  72.                {
  73.                   options.ad_finished();
  74.                };
  75.                var _loc14_ = MochiAd._getRes(options);
  76.                var _loc4_ = _loc14_[0];
  77.                var _loc13_ = _loc14_[1];
  78.                mc._x = _loc4_ * 0.5;
  79.                mc._y = _loc13_ * 0.5;
  80.                var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  81.                chk._x = _loc4_ * -0.5;
  82.                chk._y = _loc13_ * -0.5;
  83.                var _loc6_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  84.                if(options.no_progress_bar)
  85.                {
  86.                   _loc6_._visible = false;
  87.                   delete options.no_progress_bar;
  88.                }
  89.                else
  90.                {
  91.                   _loc6_._x = 10;
  92.                   _loc6_._y = _loc13_ - 20;
  93.                }
  94.                var _loc21_ = options.color;
  95.                delete options.color;
  96.                var _loc19_ = options.background;
  97.                delete options.background;
  98.                var _loc23_ = options.outline;
  99.                delete options.outline;
  100.                var _loc5_ = _loc6_.createEmptyMovieClip("_outline",1);
  101.                _loc5_.beginFill(_loc19_);
  102.                _loc5_.moveTo(0,0);
  103.                _loc5_.lineTo(_loc4_ - 20,0);
  104.                _loc5_.lineTo(_loc4_ - 20,10);
  105.                _loc5_.lineTo(0,10);
  106.                _loc5_.lineTo(0,0);
  107.                _loc5_.endFill();
  108.                var _loc3_ = _loc6_.createEmptyMovieClip("_inside",2);
  109.                _loc3_.beginFill(_loc21_);
  110.                _loc3_.moveTo(0,0);
  111.                _loc3_.lineTo(_loc4_ - 20,0);
  112.                _loc3_.lineTo(_loc4_ - 20,10);
  113.                _loc3_.lineTo(0,10);
  114.                _loc3_.lineTo(0,0);
  115.                _loc3_.endFill();
  116.                _loc3_._xscale = 0;
  117.                var _loc7_ = _loc6_.createEmptyMovieClip("_outline",3);
  118.                _loc7_.lineStyle(0,_loc23_,100);
  119.                _loc7_.moveTo(0,0);
  120.                _loc7_.lineTo(_loc4_ - 20,0);
  121.                _loc7_.lineTo(_loc4_ - 20,10);
  122.                _loc7_.lineTo(0,10);
  123.                _loc7_.lineTo(0,0);
  124.                chk.ad_msec = _loc22_;
  125.                chk.ad_timeout = _loc25_;
  126.                chk.started = getTimer();
  127.                chk.showing = false;
  128.                chk.last_pcnt = 0;
  129.                chk.fadeout_time = fadeout_time;
  130.                chk.fadeFunction = function()
  131.                {
  132.                   var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  133.                   if(_loc2_ > 0)
  134.                   {
  135.                      this._parent._alpha = _loc2_;
  136.                   }
  137.                   else
  138.                   {
  139.                      var _loc3_ = this._parent._parent;
  140.                      MochiAd.unload(_loc3_);
  141.                      delete this.onEnterFrame;
  142.                   }
  143.                };
  144.                mc.lc.regContLC = function(lc_name)
  145.                {
  146.                   mc._containerLCName = lc_name;
  147.                };
  148.                var sendHostProgress = false;
  149.                mc.lc.sendHostLoadProgress = function(lc_name)
  150.                {
  151.                   sendHostProgress = true;
  152.                };
  153.                mc.lc.adLoaded = options.ad_loaded;
  154.                mc.lc.adSkipped = options.ad_skipped;
  155.                mc.lc.adjustProgress = function(msec)
  156.                {
  157.                   var _loc2_ = this.mc._mochiad_wait;
  158.                   _loc2_.server_control = true;
  159.                   _loc2_.started = getTimer();
  160.                   _loc2_.ad_msec = msec;
  161.                };
  162.                mc.lc.rpc = function(callbackID, arg)
  163.                {
  164.                   MochiAd.rpc(clip,callbackID,arg);
  165.                };
  166.                mc.rpcTestFn = function(s)
  167.                {
  168.                   trace("[MOCHIAD rpcTestFn] " + s);
  169.                   return s;
  170.                };
  171.                chk.onEnterFrame = function()
  172.                {
  173.                   var _loc6_ = this._parent._parent;
  174.                   var _loc11_ = this._parent._mochiad_ctr;
  175.                   var _loc5_ = getTimer() - this.started;
  176.                   var _loc3_ = false;
  177.                   var _loc4_ = _loc6_.getBytesTotal();
  178.                   var _loc8_ = _loc6_.getBytesLoaded();
  179.                   var _loc2_ = 100 * _loc8_ / _loc4_;
  180.                   var _loc10_ = 100 * _loc5_ / chk.ad_msec;
  181.                   var _loc9_ = this._mochiad_bar._inside;
  182.                   var _loc13_ = Math.min(100,Math.min(_loc2_ || 0,_loc10_));
  183.                   _loc13_ = Math.max(this.last_pcnt,_loc13_);
  184.                   this.last_pcnt = _loc13_;
  185.                   _loc9_._xscale = _loc13_;
  186.                   options.ad_progress(_loc13_);
  187.                   if(sendHostProgress)
  188.                   {
  189.                      clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"hostLoadPcnt",pcnt:_loc2_});
  190.                      if(_loc2_ == 100)
  191.                      {
  192.                         sendHostProgress = false;
  193.                      }
  194.                   }
  195.                   if(!chk.showing)
  196.                   {
  197.                      var _loc7_ = _loc11_.getBytesTotal();
  198.                      if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  199.                      {
  200.                         chk.showing = true;
  201.                         chk.started = getTimer();
  202.                      }
  203.                      else if(_loc5_ > chk.ad_timeout && _loc2_ == 100)
  204.                      {
  205.                         options.ad_failed();
  206.                         _loc3_ = true;
  207.                      }
  208.                   }
  209.                   if(_loc5_ > chk.ad_msec)
  210.                   {
  211.                      _loc3_ = true;
  212.                   }
  213.                   if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  214.                   {
  215.                      if(this.server_control)
  216.                      {
  217.                         delete this.onEnterFrame;
  218.                      }
  219.                      else
  220.                      {
  221.                         this.fadeout_start = getTimer();
  222.                         this.onEnterFrame = chk.fadeFunction;
  223.                      }
  224.                   }
  225.                };
  226.             };
  227.             _global.MochiAd = function()
  228.             {
  229.             }.showClickAwayAd = function(options)
  230.             {
  231.                var _loc9_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showClickAwayAd",res:"300x250",no_bg:true,ad_started:function()
  232.                {
  233.                },ad_finished:function()
  234.                {
  235.                },ad_loaded:function(width, height)
  236.                {
  237.                },ad_failed:function()
  238.                {
  239.                   trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  240.                },ad_skipped:function()
  241.                {
  242.                }};
  243.                options = MochiAd._parseOptions(options,_loc9_);
  244.                var clip = options.clip;
  245.                var _loc8_ = options.ad_timeout;
  246.                delete options.ad_timeout;
  247.                if(!MochiAd.load(options))
  248.                {
  249.                   options.ad_failed();
  250.                   options.ad_finished();
  251.                   return undefined;
  252.                }
  253.                options.ad_started();
  254.                var mc = clip._mochiad;
  255.                mc.onUnload = function()
  256.                {
  257.                   options.ad_finished();
  258.                };
  259.                var _loc4_ = MochiAd._getRes(options);
  260.                var _loc10_ = _loc4_[0];
  261.                var _loc7_ = _loc4_[1];
  262.                mc._x = _loc10_ * 0.5;
  263.                mc._y = _loc7_ * 0.5;
  264.                var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  265.                chk.ad_timeout = _loc8_;
  266.                chk.started = getTimer();
  267.                chk.showing = false;
  268.                mc.lc.adLoaded = options.ad_loaded;
  269.                mc.lc.adSkipped = options.ad_skipped;
  270.                mc.lc.rpc = function(callbackID, arg)
  271.                {
  272.                   MochiAd.rpc(clip,callbackID,arg);
  273.                };
  274.                mc.rpcTestFn = function(s)
  275.                {
  276.                   trace("[MOCHIAD rpcTestFn] " + s);
  277.                   return s;
  278.                };
  279.                var _loc20_ = false;
  280.                mc.lc.regContLC = function(lc_name)
  281.                {
  282.                   mc._containerLCName = lc_name;
  283.                };
  284.                chk.onEnterFrame = function()
  285.                {
  286.                   var _loc5_ = this._parent._mochiad_ctr;
  287.                   var _loc4_ = getTimer() - this.started;
  288.                   var _loc2_ = false;
  289.                   if(!chk.showing)
  290.                   {
  291.                      var _loc3_ = _loc5_.getBytesTotal();
  292.                      if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  293.                      {
  294.                         _loc2_ = true;
  295.                         chk.showing = true;
  296.                         chk.started = getTimer();
  297.                      }
  298.                      else if(_loc4_ > chk.ad_timeout)
  299.                      {
  300.                         options.ad_failed();
  301.                         _loc2_ = true;
  302.                      }
  303.                   }
  304.                   if(_loc2_)
  305.                   {
  306.                      delete this.onEnterFrame;
  307.                   }
  308.                };
  309.             };
  310.             _global.MochiAd = function()
  311.             {
  312.             }.showInterLevelAd = function(options)
  313.             {
  314.                var _loc13_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd",ad_started:function()
  315.                {
  316.                   this.clip.stop();
  317.                },ad_finished:function()
  318.                {
  319.                   this.clip.play();
  320.                },ad_failed:function()
  321.                {
  322.                   trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  323.                },ad_loaded:function(width, height)
  324.                {
  325.                },ad_skipped:function()
  326.                {
  327.                }};
  328.                options = MochiAd._parseOptions(options,_loc13_);
  329.                var clip = options.clip;
  330.                var _loc10_ = 11000;
  331.                var _loc12_ = options.ad_timeout;
  332.                delete options.ad_timeout;
  333.                var fadeout_time = options.fadeout_time;
  334.                delete options.fadeout_time;
  335.                if(!MochiAd.load(options))
  336.                {
  337.                   options.ad_failed();
  338.                   options.ad_finished();
  339.                   return undefined;
  340.                }
  341.                options.ad_started();
  342.                var mc = clip._mochiad;
  343.                mc.onUnload = function()
  344.                {
  345.                   options.ad_finished();
  346.                };
  347.                var _loc5_ = MochiAd._getRes(options);
  348.                var _loc14_ = _loc5_[0];
  349.                var _loc11_ = _loc5_[1];
  350.                mc._x = _loc14_ * 0.5;
  351.                mc._y = _loc11_ * 0.5;
  352.                var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  353.                chk.ad_msec = _loc10_;
  354.                chk.ad_timeout = _loc12_;
  355.                chk.started = getTimer();
  356.                chk.showing = false;
  357.                chk.fadeout_time = fadeout_time;
  358.                chk.fadeFunction = function()
  359.                {
  360.                   var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  361.                   if(_loc2_ > 0)
  362.                   {
  363.                      this._parent._alpha = _loc2_;
  364.                   }
  365.                   else
  366.                   {
  367.                      var _loc3_ = this._parent._parent;
  368.                      MochiAd.unload(_loc3_);
  369.                      delete this.onEnterFrame;
  370.                   }
  371.                };
  372.                mc.lc.adLoaded = options.ad_loaded;
  373.                mc.lc.adSkipped = options.ad_skipped;
  374.                mc.lc.adjustProgress = function(msec)
  375.                {
  376.                   var _loc2_ = this.mc._mochiad_wait;
  377.                   _loc2_.server_control = true;
  378.                   _loc2_.started = getTimer();
  379.                   _loc2_.ad_msec = msec - 250;
  380.                };
  381.                mc.lc.rpc = function(callbackID, arg)
  382.                {
  383.                   MochiAd.rpc(clip,callbackID,arg);
  384.                };
  385.                mc.rpcTestFn = function(s)
  386.                {
  387.                   trace("[MOCHIAD rpcTestFn] " + s);
  388.                   return s;
  389.                };
  390.                chk.onEnterFrame = function()
  391.                {
  392.                   var _loc5_ = this._parent._mochiad_ctr;
  393.                   var _loc4_ = getTimer() - this.started;
  394.                   var _loc2_ = false;
  395.                   if(!chk.showing)
  396.                   {
  397.                      var _loc3_ = _loc5_.getBytesTotal();
  398.                      if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  399.                      {
  400.                         chk.showing = true;
  401.                         chk.started = getTimer();
  402.                      }
  403.                      else if(_loc4_ > chk.ad_timeout)
  404.                      {
  405.                         options.ad_failed();
  406.                         _loc2_ = true;
  407.                      }
  408.                   }
  409.                   if(_loc4_ > chk.ad_msec)
  410.                   {
  411.                      _loc2_ = true;
  412.                   }
  413.                   if(_loc2_)
  414.                   {
  415.                      if(this.server_control)
  416.                      {
  417.                         delete this.onEnterFrame;
  418.                      }
  419.                      else
  420.                      {
  421.                         this.fadeout_start = getTimer();
  422.                         this.onEnterFrame = this.fadeFunction;
  423.                      }
  424.                   }
  425.                };
  426.             };
  427.             _global.MochiAd = function()
  428.             {
  429.             }.showPreloaderAd = function(options)
  430.             {
  431.                trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
  432.                MochiAd.showPreGameAd(options);
  433.             };
  434.             _global.MochiAd = function()
  435.             {
  436.             }.showTimedAd = function(options)
  437.             {
  438.                trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
  439.                MochiAd.showInterLevelAd(options);
  440.             };
  441.             _global.MochiAd = function()
  442.             {
  443.             }._allowDomains = function(server)
  444.             {
  445.                var _loc1_ = server.split("/")[2].split(":")[0];
  446.                if(System.security)
  447.                {
  448.                   if(System.security.allowDomain)
  449.                   {
  450.                      System.security.allowDomain("*");
  451.                      System.security.allowDomain(_loc1_);
  452.                   }
  453.                   if(System.security.allowInsecureDomain)
  454.                   {
  455.                      System.security.allowInsecureDomain("*");
  456.                      System.security.allowInsecureDomain(_loc1_);
  457.                   }
  458.                }
  459.                return _loc1_;
  460.             };
  461.             _global.MochiAd = function()
  462.             {
  463.             }.load = function(options)
  464.             {
  465.                var _loc13_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  466.                options = MochiAd._parseOptions(options,_loc13_);
  467.                options.swfv = options.clip.getSWFVersion() || 6;
  468.                options.mav = MochiAd.getVersion();
  469.                var _loc9_ = options.clip;
  470.                if(!MochiAd._isNetworkAvailable())
  471.                {
  472.                   return null;
  473.                }
  474.                if(_loc9_._mochiad_loaded)
  475.                {
  476.                   return null;
  477.                }
  478.                var _loc12_ = options.depth;
  479.                delete options.depth;
  480.                var _loc6_ = _loc9_.createEmptyMovieClip("_mochiad",_loc12_);
  481.                var _loc11_ = MochiAd._getRes(options);
  482.                options.res = _loc11_[0] + "x" + _loc11_[1];
  483.                options.server += options.id;
  484.                delete options.id;
  485.                _loc9_._mochiad_loaded = true;
  486.                var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  487.                for(var _loc7_ in options)
  488.                {
  489.                   _loc4_[_loc7_] = options[_loc7_];
  490.                }
  491.                var _loc10_ = _loc4_.server;
  492.                delete _loc4_.server;
  493.                var _loc14_ = MochiAd._allowDomains(_loc10_);
  494.                _loc6_.onEnterFrame = function()
  495.                {
  496.                   if(this._mochiad_ctr._url != this._url)
  497.                   {
  498.                      this.onEnterFrame = function()
  499.                      {
  500.                         if(!this._mochiad_ctr)
  501.                         {
  502.                            delete this.onEnterFrame;
  503.                            MochiAd.unload(this._parent);
  504.                         }
  505.                      };
  506.                   }
  507.                };
  508.                var _loc5_ = new LocalConnection();
  509.                var _loc8_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  510.                _loc5_.mc = _loc6_;
  511.                _loc5_.name = _loc8_;
  512.                _loc5_.hostname = _loc14_;
  513.                _loc5_.allowDomain = function(d)
  514.                {
  515.                   return true;
  516.                };
  517.                _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  518.                _loc5_.connect(_loc8_);
  519.                _loc6_.lc = _loc5_;
  520.                _loc4_.lc = _loc8_;
  521.                _loc4_.st = getTimer();
  522.                _loc4_.loadMovie(_loc10_ + ".swf","POST");
  523.                return _loc6_;
  524.             };
  525.             _global.MochiAd = function()
  526.             {
  527.             }.unload = function(clip)
  528.             {
  529.                if(typeof clip == "undefined")
  530.                {
  531.                   clip = _root;
  532.                }
  533.                if(clip.clip && clip.clip._mochiad)
  534.                {
  535.                   clip = clip.clip;
  536.                }
  537.                if(!clip._mochiad)
  538.                {
  539.                   return false;
  540.                }
  541.                if(clip._mochiad._containerLCName != undefined)
  542.                {
  543.                   clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"unload"});
  544.                }
  545.                clip._mochiad.removeMovieClip();
  546.                delete clip._mochiad_loaded;
  547.                delete clip._mochiad;
  548.                return true;
  549.             };
  550.             _global.MochiAd = function()
  551.             {
  552.             }._isNetworkAvailable = function()
  553.             {
  554.                if(System.security)
  555.                {
  556.                   var _loc1_ = System.security;
  557.                   if(_loc1_.sandboxType == "localWithFile")
  558.                   {
  559.                      return false;
  560.                   }
  561.                }
  562.                return true;
  563.             };
  564.             _global.MochiAd = function()
  565.             {
  566.             }._getRes = function(options)
  567.             {
  568.                var _loc3_ = options.clip.getBounds();
  569.                var _loc2_ = 0;
  570.                var _loc1_ = 0;
  571.                if(typeof options.res != "undefined")
  572.                {
  573.                   var _loc4_ = options.res.split("x");
  574.                   _loc2_ = parseFloat(_loc4_[0]);
  575.                   _loc1_ = parseFloat(_loc4_[1]);
  576.                }
  577.                else
  578.                {
  579.                   _loc2_ = _loc3_.xMax - _loc3_.xMin;
  580.                   _loc1_ = _loc3_.yMax - _loc3_.yMin;
  581.                }
  582.                if(_loc2_ == 0 || _loc1_ == 0)
  583.                {
  584.                   _loc2_ = Stage.width;
  585.                   _loc1_ = Stage.height;
  586.                }
  587.                return [_loc2_,_loc1_];
  588.             };
  589.             _global.MochiAd = function()
  590.             {
  591.             }._parseOptions = function(options, defaults)
  592.             {
  593.                var _loc4_ = {};
  594.                for(var _loc8_ in defaults)
  595.                {
  596.                   _loc4_[_loc8_] = defaults[_loc8_];
  597.                }
  598.                if(options)
  599.                {
  600.                   for(_loc8_ in options)
  601.                   {
  602.                      _loc4_[_loc8_] = options[_loc8_];
  603.                   }
  604.                }
  605.                if(_root.mochiad_options)
  606.                {
  607.                   var _loc5_ = _root.mochiad_options.split("&");
  608.                   var _loc2_ = 0;
  609.                   while(_loc2_ < _loc5_.length)
  610.                   {
  611.                      var _loc3_ = _loc5_[_loc2_].split("=");
  612.                      _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  613.                      _loc2_ = _loc2_ + 1;
  614.                   }
  615.                }
  616.                if(_loc4_.id == "test")
  617.                {
  618.                   trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
  619.                }
  620.                return _loc4_;
  621.             };
  622.             _global.MochiAd = function()
  623.             {
  624.             }.rpc = function(clip, callbackID, arg)
  625.             {
  626.                switch(arg.id)
  627.                {
  628.                   case "setValue":
  629.                      MochiAd.setValue(clip,arg.objectName,arg.value);
  630.                      break;
  631.                   case "getValue":
  632.                      var _loc4_ = MochiAd.getValue(clip,arg.objectName);
  633.                      clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc4_);
  634.                      break;
  635.                   case "runMethod":
  636.                      var _loc3_ = MochiAd.runMethod(clip,arg.method,arg.args);
  637.                      clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc3_);
  638.                      break;
  639.                   default:
  640.                      trace("[mochiads rpc] unknown rpc id: " + arg.id);
  641.                }
  642.             };
  643.             _global.MochiAd = function()
  644.             {
  645.             }.setValue = function(base, objectName, value)
  646.             {
  647.                var _loc2_ = objectName.split(".");
  648.                var _loc1_ = undefined;
  649.                _loc1_ = 0;
  650.                while(_loc1_ < _loc2_.length - 1)
  651.                {
  652.                   if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  653.                   {
  654.                      return undefined;
  655.                   }
  656.                   base = base[_loc2_[_loc1_]];
  657.                   _loc1_ = _loc1_ + 1;
  658.                }
  659.                base[_loc2_[_loc1_]] = value;
  660.             };
  661.             _global.MochiAd = function()
  662.             {
  663.             }.getValue = function(base, objectName)
  664.             {
  665.                var _loc2_ = objectName.split(".");
  666.                var _loc1_ = undefined;
  667.                _loc1_ = 0;
  668.                while(_loc1_ < _loc2_.length - 1)
  669.                {
  670.                   if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  671.                   {
  672.                      return undefined;
  673.                   }
  674.                   base = base[_loc2_[_loc1_]];
  675.                   _loc1_ = _loc1_ + 1;
  676.                }
  677.                return base[_loc2_[_loc1_]];
  678.             };
  679.             _global.MochiAd = function()
  680.             {
  681.             }.runMethod = function(base, methodName, argsArray)
  682.             {
  683.                var _loc2_ = methodName.split(".");
  684.                var _loc1_ = undefined;
  685.                _loc1_ = 0;
  686.                while(_loc1_ < _loc2_.length - 1)
  687.                {
  688.                   if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  689.                   {
  690.                      return undefined;
  691.                   }
  692.                   base = base[_loc2_[_loc1_]];
  693.                   _loc1_ = _loc1_ + 1;
  694.                }
  695.                if(typeof base[_loc2_[_loc1_]] == "function")
  696.                {
  697.                   return base[_loc2_[_loc1_]].apply(base,argsArray);
  698.                }
  699.                return undefined;
  700.             };
  701.             ┬º┬ºpush(ASSetPropFlags(_global.MochiAd.prototype,null,1));
  702.          }
  703.          ┬º┬ºpop();
  704.          break;
  705.       }
  706.       if(eval("\x01") == 819)
  707.       {
  708.          set("\x01",eval("\x01") - 562);
  709.          var ┬º┬ºpop() = function ┬º\x04\x05┬º()
  710.          {
  711.             set("\x03",1660 % 511 * 5);
  712.             return eval("\x03");
  713.          };
  714.       }
  715.       else if(eval("\x01") == 974)
  716.       {
  717.          set("\x01",eval("\x01") - 485);
  718.       }
  719.       else if(eval("\x01") == 532)
  720.       {
  721.          set("\x01",eval("\x01") - 128);
  722.          if(function ┬º\x04\x05┬º()
  723.          {
  724.             set("\x03",1660 % 511 * 5);
  725.             return eval("\x03");
  726.          })
  727.          {
  728.             set("\x01",eval("\x01") - 327);
  729.          }
  730.       }
  731.       else if(eval("\x01") == 50)
  732.       {
  733.          set("\x01",eval("\x01") + 769);
  734.          ┬º┬ºpush("\x0f");
  735.          ┬º┬ºpush(1);
  736.       }
  737.       else if(eval("\x01") == 850)
  738.       {
  739.          set("\x01",eval("\x01") - 332);
  740.          ┬º┬ºpush(!function ┬º\x04\x05┬º()
  741.          {
  742.             set("\x03",1660 % 511 * 5);
  743.             return eval("\x03");
  744.          });
  745.       }
  746.       else if(eval("\x01") == 77)
  747.       {
  748.          set("\x01",eval("\x01") - 27);
  749.       }
  750.       else if(eval("\x01") == 518)
  751.       {
  752.          set("\x01",eval("\x01") + 456);
  753.          if(function ┬º\x04\x05┬º()
  754.          {
  755.             set("\x03",1660 % 511 * 5);
  756.             return eval("\x03");
  757.          })
  758.          {
  759.             set("\x01",eval("\x01") - 485);
  760.          }
  761.       }
  762.       else if(eval("\x01") == 70)
  763.       {
  764.          set("\x01",eval("\x01") + 780);
  765.          ┬º┬ºpush(eval(function ┬º\x04\x05┬º()
  766.          {
  767.             set("\x03",1660 % 511 * 5);
  768.             return eval("\x03");
  769.          }));
  770.       }
  771.       else
  772.       {
  773.          if(eval("\x01") == 404)
  774.          {
  775.             set("\x01",eval("\x01") - 327);
  776.             ┬º┬ºpush(┬º┬ºpop() < function ┬º\x04\x05┬º()
  777.             {
  778.                set("\x03",1660 % 511 * 5);
  779.                return eval("\x03");
  780.             });
  781.             break;
  782.          }
  783.          if(eval("\x01") == 636)
  784.          {
  785.             set("\x01",eval("\x01") - 636);
  786.             break;
  787.          }
  788.          if(eval("\x01") == 257)
  789.          {
  790.             set("\x01",eval("\x01") - 187);
  791.             ┬º┬ºpush("\x0f");
  792.          }
  793.          else
  794.          {
  795.             if(eval("\x01") != 780)
  796.             {
  797.                break;
  798.             }
  799.             set("\x01",eval("\x01") - 730);
  800.          }
  801.       }
  802.    }
  803. }
  804.